Portable and Accurate Collection of Calling-Context-Sensitive Bytecode Metrics for the Java Virtual Machine

Calling-context profiles and dynamic metrics at the bytecode level are important for profiling, workload characterization, program comprehension, and reverse engineering. Prevailing tools for collecting calling-context profiles or dynamic bytecode metrics often provide only incomplete information or suffer from limited compatibility with standard JVMs. However, completeness and accuracy of the profiles is essential for tasks such as workload characterization, and compatibility with standard JVMs is important to ensure that complex workloads can be executed. In this paper, we present the design and implementation of JP2, a new tool that profiles both the inter- and intra-procedural control flow of workloads on standard JVMs. JP2 produces calling-context profiles preserving callsite information, as well as execution statistics at the level of individual basic blocks of code. JP2 is complemented with scripts that compute various dynamic bytecode metrics from the profiles. As a case-study and tutorial on the use of JP2, we use it for cross-profiling for an embedded Java processor

A comprehensive toolchain for workload characterization across JVM languages

The Java Virtual Machine (JVM) today hosts implementations of numerous languages. To achieve high performance, JVM implementations rely on heuristics in choosing compiler optimizations and adapting garbage collection behavior. Historically, these heuristics have been tuned to suit the dynamics of Java programs only. This leads to unnecessarily poor performance in case of non-Java languages, which often exhibit systematic differences in workload behavior. Dynamic metrics characterizing the workload help to identify and quantify useful optimizations, but so far, no cohesive suite of metrics has adequately covered properties that vary systematically between Java and non-Java workloads. We present a suite of such metrics, justifying our choice with reference to a range of guest languages. These metrics are implemented on a common portable infrastructure which ensures ease of deployment and customization

A Prospective Study on the Impact and Out-of-Pocket Costs of Dengue Illness in International Travelers.

Although the costs of dengue illness to patients and households have been extensively studied in endemic populations, international travelers have not been the focus of costing studies. As globalization and human travel activities intensify, travelers are increasingly at risk for emerging and reemerging infectious diseases, such as dengue. This exploratory study aims to investigate the impact and out-of-pocket costs of dengue illness among travelers. We conducted a prospective study in adult travelers with laboratory-confirmed dengue and recruited patients at travel medicine clinics in eight different countries from December 2013 to December 2015. Using a structured questionnaire, we collected information on patients and their health-care utilization and out-of-pocket expenditures, as well as income and other financial losses they incurred because of dengue illness. A total of 90 patients participated in the study, most of whom traveled for tourism (74%) and visited countries in Asia (82%). Although 22% reported hospitalization and 32% receiving ambulatory care while traveling, these percentages were higher at 39% and 71%, respectively, after returning home. The out-of-pocket direct and indirect costs of dengue illness were US$421 (SD 744) and US$571 (SD 1,913) per episode, respectively, averaging to a total out-of-pocket cost of US$992 (SD 2,052) per episode. The study findings suggest that international travelers incur important direct and indirect costs because of dengue-related illness. This study is the first to date to investigate the impact and out-of-pocket costs of travel-related dengue illness from the patient's perspective and paves the way for future economic burden studies in this population

Design and Analysis of a Scala Benchmark Suite for the Java Virtual Machine

In the last decade, virtual machines (VMs) for high-level languages have become pervasive, as they promise both portability and high performance. However, these virtual machines were often designed to support just a single language well. The design of the Java Virtual Machine (JVM), for example, is heavily influenced by the Java programming language. Despite its current bias towards Java, in recent years the JVM in particular has been targeted by numerous new languages: Scala, Groovy, Clojure, and others. This trend has not been reflected in JVM research, though; all major benchmark suites for the JVM are still firmly focused on the Java language rather than on the language ecosystem as a whole. This state of affairs threatens to perpetuate the bias towards Java, as JVM implementers strive to “make the common case fast.” But what is common for Java may be uncommon for other, popular languages. One of these other languages is Scala, a language with both object-oriented and functional features, whose popularity has grown tremendously since its first public appearance in 2003. What characteristics Scala programs have or have not in common with Java programs has been an open question, though. One contribution of this thesis is therefore the design of a Scala benchmark suite that is on par with modern, widely-accepted Java benchmark suites. Another contribution is the subsequent analysis of this suite and an in-depth, VM-independent comparison with the DaCapo 9.12 benchmark suite, the premier suite used in JVM research. The analysis shows that Scala programs exhibit not only a distinctive instruction mix but also object demographics close to those of the Scala language’s functional ancestors. This thesis furthermore shows that these differences can have a marked effect on the performance of Scala programs on modern high-performance JVMs. While JVMs exhibit remarkably similar performance on Java programs, the performance of Scala programs varies considerably, with the fastest JVM being more than three times faster than the slowest

Scala = Java (mod JVM): On the Performance Characteristics of Scala Programs on the Java Virtual Machine

In recent years, the Java Virtual Machine has become an attractive target for a multitude of programming languages, one of which is Scala. But while the Scala compiler emits plain Java bytecode, the performance characteristics of Scala programs are not necessarily similar to those of Java programs. We therefore propose to complement a popular Java benchmark suite with several Scala programs and to subsequently evaluate their performance using VM-independent metrics

Encoding the Java Virtual Machine's Instruction Set

New toolkits that parse, analyze, and transform Java Bytecode are frequently developed from scratch to obtain a representation suitable for a particular purpose. But, while the functionality implemented by these toolkits to read in class files and do basic control- and data-flow analyses is comparable, it is implemented over and over again. Differences manifest themselves mainly in minor technical issues. To avoid the repetitive development of similar functionality, we have developed an XML-based language for specifying bytecode-based instruction sets. Using this language, we have encoded the instruction set of the Java Virtual Machine such that it can directly be used, e.g., to generate the skeleton of bytecode-based tools. The XML format hereby specifies both the format of the instructions and their effect on the stack and the local registers upon execution. This enables developers of static analyses to generate generic control- and data-flow analyses, e.g., an analysis that transforms Java Bytecode into static single assignment form. To assess the usefulness of our approach, we have used the encoding of the Java Virtual Machine's instruction set to develop a framework for the analysis and transformation of Java class files. The evaluation shows that using the specification significantly reduces the development effort when compared to manual development

Efficient language implementation with ALIA4J and EMFText: forum demonstration

Developing extensions to general-purpose langauges or domain-specific languages with support for new kinds of abstractions is an ongoing trend. Modern language workbenches, such as EMFText of Xtext, support this trend and facilitate implementing langauges in terms of transformations from the new language into an established (intermediate) language. Often, however, the implementation of one element in the source language becomes scattered and tangled in the target language, which makes transformations complex. Furthermore, even though many languages share core concepts, current approaches do not support sharing transformations that implement their semantics; the only possibility of re-using transformations from a language is to extend it syntactically.\ud We have identified dispatching as fundamental to most abstraction mechanisms. With the ALIA4J approach, we provide a meta-model of dispatching to act as rich and extensible intermediate language that allows more direct transformation. The semantics of core language concepts can be modularly implemented as extension of the meta-model. For the execution of the intermediate language, we provide both platform-independent and platform-dependent Java Virtual Machine extensions, the latter of which even allows the modular implementation of machine code optimizations.\ud In this demo, participants get an overview of advanced dispatching and the ALIA4J approach. By the example of a language for text-based adventure games, they will see the usage of ALIA4J as back-end for a language developed in EMFText. Finally, the implementation of new atomic language concepts and their optimization is demonstrated

The ALIA4J approach to efficient language implementation

\ud New programming languages are frequently designed to improve upon other languages or to simplify programs through domain-specific abstractions. They are often implemented as transformations to an established (intermediate) language (IL). But while many new languages overlap in the semantics of their core concepts, re-using the corresponding transformations is limited by existing compiler implementation frameworks. In the ALIA4J approach, we have identified dispatching as fundamental to most abstraction mechanisms and provide a meta-model of dispatching as a rich, extensible IL. Based on this meta-model, the semantics of new atomic language concepts can be implemented in a modular and portable fashion. For the execution of the IL, we provide both platform-independent and platform-dependent Java Virtual Machine extensions, the latter of which allows the modular implementation of machine code optimizations.\ud \ud In this demo, participants get an overview of advanced dispatching and the ALIA4J approach. By the example of a language for text-based adventure games, they will see the usage of ALIA4J as back-end for a language developed in a modern Language Workbench. Finally, the implementation of new atomic language concepts and their optimization is demonstrated

Generic IDE Support for Dispatch-Based Composition

Programming-language research produces a significant number of new programming styles to improve the composability of programs. This increases re-usability as well as other quality characteristics. But although they offer interesting composition concepts, new programming languages are rarely used because IDE support, which developers are used to, is missing. Examples of such IDE support are the visualization of call hierarchies or interactive debugging. While some languages, e.g., AspectJ, eventually reach a more mature level with elaborate IDE integration, not all language designers are able to invest this much effort towards IDE integration. Furthermore, the IDE integration of AspectJ also has its limitations; when debugging, the developer is confronted with synthetic code with no exact correspondence in the source code. As a result, the developer needs to understand the transformations performed by the compiler. Finally, some information invariably gets lost during weaving, e.g., the ability to map code evaluating pointcut designators to their definition in the source code. In this paper, we propose to implement generic IDE tools for programming languages that provide advanced dispatching mechanisms. Such languages, including predicate dispatching and pointcut-advice languages, can be mapped to our execution model, called ALIA. The same execution model can then drive debugging functionality as well as static IDE services